const http = require("http")
const fs = require("fs")
const qs = require("querystring");

http.createServer((req,res)=>{
    if(req.url.includes("/api")){
        dataRequire(req,res);
    }else{
        fileRequire(req,res);
    }
}).listen(3000,()=>{
    console.log("服务器开启成功，地址为：http://localhost:3000")
})

function dataRequire(req,res){
    let str = "";
    req.on("data",(chunk)=>{
        str += chunk;
    })
    req.on("end",()=>{
        let data;
        if(str){
            data = qs.parse(str);
        }else{
            const urlObj = new URL("http://localhost:3000" + req.url);
            data = qs.parse(urlObj.search.slice(1));
        }
        // 1. 过滤前端请求，判断请求功能
        switch(data.type){
            case "getPro":
                // 查询数据库中的数据
                getMsg(req, res, obj);
                break;
                                 
                            case "register":
                                // 注册
                                register(req,res,data);break;
                            case "login":
                                // 登录
                                login(req,res,data);break;
                                case "getDetail":
                                    getDetail(req, res, obj);
                                    break;
                        }
                    })
                }
                
 // 获取单个商品详情
function getDetail(req, res, reqData){

    fs.readFile("./database/commodity.json", "utf-8", (err, data)=>{
        const arr = JSON.parse(data).msg.filter(val=>val.proId===reqData.id);
        // console.log(arr);

        const obj = {}
        obj.code = 1;
        obj.title = "获取详情成功";
        obj.data = arr[0];
        // 直接返回前端
        res.write(JSON.stringify(obj));
        res.end();

    })

}
               
// 假设的临时的数据库
// let userMsg = [{username:"admin",password:"123123"},{},{}]
let userMsg = [];

function register(req,res,data){
    // console.log("注册", data);
    // 判断用户名是否重复
    let flag = userMsg.some(val=>val.username === data.username);
    // 准备一个对象，用于存储向前端返回的信息
    let msg = {};
    if(flag){
        // 是，返回注册失败
        msg.code = 0;
        msg.title = "注册失败，用户名重复";
    }else{
        // 否，将用户名和密码存入数据库
        userMsg.push({
            username:data.username,
            password:data.password
        })
        // 返回注册成功
        msg.code = 1;
        msg.title = "注册成功";
    }
    // 将对象转成json，返回给前端
    res.write(JSON.stringify(msg));
    res.end();
}

function login(req,res,data){
    console.log(res, data);
    // - 判断用户名是否存在
    let i = 0;
    let flag = userMsg.some((val,idx)=>{
        i = idx;
        return val.username === data.username
    })
    let msg = {};
    if(flag){
        // - 是
        // - 判断密码是否符合
        if(userMsg[i].password === data.password){
            // - 是，返回登录成功
            msg.code = 1;
            msg.title = "登录成功";
            msg.data = userMsg[i];
        }else{
            // - 否，返回密码不对
            msg.code = 0;
            msg.title = "密码不对";
            msg.data = {};
        }
    }else{
        // - 否，返回用户名不存在
        msg.code = 2;
        msg.title = "用户名不存在";
        msg.data = {};
    }
    res.write(JSON.stringify(msg));
    res.end();
}




function getMsg(req,res,data){
    fs.readFile("./data/getPro.json", "utf-8", (err, data)=>{
    // 2. 调用数据库的查询功能
    select(data=>{
        // 3. 查询成功，处理数据，发送给前端
        const obj = {
            code:1,
            title:"获取成功",
            data: JSON.parse(data)
        }
        res.write(JSON.stringify(obj))
        res.end();
    },err=>{
        // 4. 查询失败，处理数据，发送给前端
        
        const obj = {
            code:0,
            title:"获取失败",
            data:err
        }
        res.write(JSON.stringify(obj))
        res.end();
    })
})
}
// ...


function fileRequire(req,res,data){
    fs.readFile("./www" + req.url.split("?")[0], (err,data)=>{
        if(err){
            res.write("404");
        }else{
            res.write(data);
        }
        res.end();
    })
}


// 封装数据库的查询功能
function select(success, error){
    // 读取文件
    fs.readFile("./database/msg.json","utf-8",(err,data)=>{
        // 读取结束后，执行成功或失败的回调函数
        if(err){
            error(err);
        }else{
            success(data);
        }
    })
}


// 封装的数据库的插入数据的功能
function insert(obj, a, b){
    fs.readFile("./database/msg.json","utf-8",(err, data)=>{
        if(err){
            b("读取失败")
        }else{
            const arr = data ? JSON.parse(data) : [];
            obj.id = Date.now();
            arr.push(obj);
            fs.writeFile("./database/msg.json", JSON.stringify(arr), err=>{
                if(err){
                    b("增加失败");
                }else{
                    a("增加成功");
                }
            })
        }
    })
}

function update(where, msg, success, error){
    // 读取数据库
    fs.readFile("./database/msg.json","utf-8",(err, data)=>{
        if(err){
            error(err);
        }else{
            // 解析数据
            const arr = JSON.parse(data);
            // 遍历数据，查询到要修改的数据
            let i;
            for(i=0;i<arr.length;i++){
                if(arr[i].id == where.id){
                    break;
                }
            }
            // 将数据从数组中修改
            arr[i] = msg;
            // 将数组重新存回去
            fs.writeFile("./database/msg.json", JSON.stringify(arr), err=>{
                if(err){
                    error("修改失败");
                }else{
                    success("修改成功");
                }
            })
        }
    })
}


function remove(where, succes, error){
    // 读取数据库
        // 解析数据
        // 遍历数据，查询到要删除的数据
        // 将数据从数组中删掉
        // 将数组重新存回去
}